package com.htgd.gardenexpo.utils;

import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.*;


/**
 * @author lihailong
 * @date
 */
@Component
public class CommonUtils {
    public static String mergeList (List<String> list){

        // 使用 StringBuilder 来拼接字符串，效率更高
        StringBuilder mergedTracks = new StringBuilder();

        List<String> cleanedList = new ArrayList<>();
        for (String s : list) {
            if (!"[]".equals(s)) {
                cleanedList.add(s);  // 去掉首尾的 [ 和 ]
            }
        }

        // 如果只有一个元素，直接返回该元素
        if (cleanedList.size() == 1) {
            mergedTracks.append(cleanedList.get(0));
            return mergedTracks.toString();  // 最终转换为 String 类型返回
        }

        // 合并 cleanedList 中的所有字符串
        for (int i = 0; i < cleanedList.size(); i++) {
            String s = cleanedList.get(i);

            // 如果是第一个数据项，保留开头的 [
            if (i == 0) {
                mergedTracks.append(s.substring(0, s.length()-1));  // 只去掉最后的 ]
            }
            // 如果是最后一个数据项，保留结尾的 ]
            else if (i == cleanedList.size() - 1) {
                mergedTracks.append(s.substring(1, s.length()));  // 只去掉最前面的 [
            }
            // 如果是中间的数据项，去掉首尾的 [ 和 ]，并加逗号分隔
            else {
                mergedTracks.append(s.substring(1, s.length() - 1));  // 去掉首尾的 [ 和 ]
            }

            // 添加逗号分隔符（只对中间数据项有效）
            if (i < cleanedList.size() - 1) {
                mergedTracks.append(",");
            }
        }


        return mergedTracks.toString();  // 最终转换为 String 类型返回
    }

    public static String formatTimeRange(String beginTime, String endTime) {
        // 提取 beginTime 和 endTime 的时间部分
        String beginTimePart = beginTime.substring(0, 19);  // 获取 "2025-04-02 19:16:15"
        String endTimePart = endTime.substring(11);  // 获取 "19:18:38" 部分

        // 拼接结果
        return beginTimePart + " - " + endTimePart;
    }

    public static String compareAndReturnLarger(String str1, String str2) {
        try {
            // 将字符串转换为 double 类型
            double num1 = Double.parseDouble(str1);
            double num2 = Double.parseDouble(str2);

            // 比较两个 double 数值并返回较大的那个的字符串表示
            if (num1 > num2) {
                return str1;
            } else {
                return str2;
            }
        } catch (NumberFormatException e) {
            // 如果转换失败，打印异常并返回一个空字符串或者可以根据需求返回默认值
            System.err.println("Invalid input: " + e.getMessage());
            return "";
        }
    }

    /**
     * 轨迹格式转换
     * @param track
     * @return
     */

    public static String[] formatTrack(String track) {
        // 去掉数组的方括号
        track = track.substring(1, track.length() - 1);

        // 分割数字
        String[] numbers = track.split(",");

        // 创建一个新的数组来存储结果
        String[] result = new String[numbers.length - 1];

        // 提取最后一位数字并拼接
        for (int i = 0; i < numbers.length - 1; i++) {
            // 获取两个相邻数字的最后一位
            String num1 = numbers[i];
            String num2 = numbers[i + 1];

            // 拼接两个数字的最后一位
            String formatted = num1.substring(num1.length() - 1) + "-" + num2.substring(num2.length() - 1);
            result[i] = formatted;  // 存储拼接结果
        }

        return result;
    }

    // 通用合并方法
    // 通用合并方法
    public static String mergeTrack(String trackS) {
        String track = trackS.replaceAll("\\s+", "");
        // 按 "#" 分割字符串，得到每个部分
        String[] parts = track.split("#");

        // 使用 StringBuilder 来构建最终的结果
        StringBuilder result = new StringBuilder();
        if(parts.length==1){
            return track;
        }

        // 遍历每个部分
        for (int i = 0; i < parts.length; i++) {
            String part = parts[i];

            // 如果是第一个部分，直接添加到结果中
            if (i == 0) {
                result.append(part.substring(0,part.length() - 1));
            } else if (i == parts.length - 1) {
                result.append(",").append(part.substring(1,part.length()));  // 保留最后一个部分的方括号
            } else {
                // 去掉每个部分的方括号，去掉后的字符串进行拼接
                part = part.substring(1, part.length() - 1);  // 去掉方括号
                result.append(",").append(part);  // 拼接到结果中
            }
        }

        // 返回最终合并后的结果
        return result.toString();
    }

    public static String kCalorie(String calorie) {
        double parseDouble = Double.parseDouble(calorie);
        double kCalorie = parseDouble / 1000;
        return String.valueOf(kCalorie);  // 或者使用 Double.toString(kCalorie)
    }

    public static boolean isValid(String idCard) {
        // 检查长度
        if (idCard == null || (idCard.length() != 15 && idCard.length() != 18)) {
            return false;
        }

        // 如果是18位，检查校验码
        if (idCard.length() == 18) {
            return isValid18(idCard);
        }

        // 如果是15位，直接验证
        return isValid15(idCard);
    }

    // 18位身份证的校验
    private static boolean isValid18(String idCard) {
        // 正则表达式检查格式
        String regex = "^[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[0-9Xx]$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(idCard);
        if (!matcher.matches()) {
            return false;
        }

        // 校验位的计算
        char[] charArray = idCard.toCharArray();
        int sum = 0;
        for (int i = 0; i < 17; i++) {
            sum += (charArray[i] - '0') * (Math.pow(2, 17 - i) % 11);
        }
        int mod = sum % 11;
        String[] checkDigit = {"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"};
        String validCheckDigit = checkDigit[mod];
        return validCheckDigit.equalsIgnoreCase(String.valueOf(charArray[17]));
    }

    // 15位身份证的简单检查（长度和格式）
    private static boolean isValid15(String idCard) {
        String regex = "^[1-9]\\d{5}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(idCard);
        return matcher.matches();
    }


    // 验证手机号
    public static boolean isValidPhoneNumber(String phoneNumber) {
        // 正则表达式：以1开头，第二位是3-9，后面是9个数字
        String regex = "^1[3-9]\\d{9}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(phoneNumber);
        return matcher.matches();
    }

    public static void main(String[] args) {
        String idCard1 = "11010519491231002X";
        String idCard2 = "11010519491231002";

        System.out.println("身份证1有效性：" + isValid(idCard1)); // 应该返回true
        System.out.println("身份证2有效性：" + isValid(idCard2)); // 应该返回true或false
    }

//    public static void main(String[] args) {
//        // 测试数据
//        String track = "[81630001690006, 81630001690002]#[81630001690002, 81630001690003]#[81630001690006, 81630001690007]";
//
//        // 调用通用合并方法
//        String mergedTrack = mergeTrack(track);
//
//        // 输出合并后的结果
//        System.out.println("Merged Track: " + mergedTrack);  // 输出: Merged Track: [1,2,2,3,4,5,6,7]
////
////        String track = "[81630001690003, 81630001690003, 81630001690004]";
////
////        // 调用格式化函数并输出结果
////        String[] formattedTrack = formatTrack(track);
////
////        // 打印 String[] 数组的格式
////        System.out.println(java.util.Arrays.toString(formattedTrack));
//    }

}
